package http;

import java.util.Random;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;

/**
 * @Author: xwg
 * @CreateDate: 2023/4/9
 */


public class Ok2 {

    public double go1(double x, double y) {
        return x / y;
    }

//    public static void main(String[] args) {
//        Ok2 ok2 = new Ok2();
//        double v = ok2.go1(1, 3);
//        System.out.println(v);
//    }

    public void go2(double x, double y, DoubleConsumer callback) {
        double v = x / y;
//        js : callback(v)
        callback.accept(v);
    }

//    public static void main(String[] args) {
//        Ok2 ok2 = new Ok2();
//        ok2.go2(1, 3, (v) -> {
//            System.out.println(v);
//        });
//    }

//    异步编程风格 必然带来形式上的回调函数 上述案例中没有考虑throw异常的情况，故而只需要一个正常处理函数。
//    回调函数可怕的地方在于回调地狱(层级越陷越深)，即回调函数内继续使用异步编程风格。
//    public static void main(String[] args) {
//        Ok2 ok2 = new Ok2();
//        ok2.go2(1, 3, (v) -> {
//            System.out.println("第一次回调：" + v);
//            ok2.go2(4, v, (w) -> {
//                System.out.println("第二次回调：" + w);
//                ok2.go2(w, 10, (u) -> {
//                    System.out.println("第三次回调：" + u);
//                });
//            });
//        });
//    }

//    反观同步风格代码
//    public static void main(String[] args) {
//        Ok2 ok2 = new Ok2();
//        double v = ok2.go1(1, 3);
//        System.out.println("第一次调用：" + v);
//        double w = ok2.go1(4, v);
//        System.out.println("第二次调用："+w);
//        double u = ok2.go1(w,10);
//        System.out.println("第三次调用："+u);
//    }
//    promise起初是为了消除回调地狱的缩进风格而改成链式调用，
//    后来又一步追求虽然实际上是异步代码，但能够让调用者使用类似同步代码风格的方式书写的await asynic 关键字
//    练习使用定时任务中开定时任务，请求一后发送请求二。

}
